<!DOCTYPE html>
<html>

<head>
    <meta charset="utf-8" />

    <script>

for (var n of fibonacci) {
  if (n > 1000)
    break;
  console.log(n);
}

// const obj = { a: 1, b: 2, c: 3 }

// function* entries(obj) {
//   for (let key of Object.keys(obj)) {
//     yield [key, obj[key]];
//   }
// }

// for (let [key, value] of entries(obj)) {
//   console.log(key, '->', value);
// }

        // let arrayLike = { length: 2, 0: 'a', 1: 'b' };
        // // // 报错
        // // for (let x of arrayLike) {
        // // console.log(x);
        // // }
        // // 正确
        // for (let x of Array.from(arrayLike)) {
        // console.log(x);
        // }


        // let { log } = console;

        // let obj = {
        //     data: ['hello', 'world'],
        //     [Symbol.iterator]() {
        //         const self = this;
        //         let index = 0;
        //         return {
        //             // next : function  next() {
        //             next() {
        //                 if (index < self.data.length) {
        //                     return {
        //                         value: self.data[index++],
        //                         done: false
        //                     };
        //                 }
        //                 return { value: undefined, done: true };
        //             }
        //         }

        //     }
        // };

        // let { data: mydata, [Symbol.iterator]: mysymboliterator } = obj;
        // log([...obj]);
        // log(mydata);
        // log(mysymboliterator);
        // log(mysymboliterator.apply(obj).next())
        
        // // var engines = new Set(["Gecko", "Trident", "Webkit", "Webkit"]);
        // // for (var e of engines) {
        // //     console.log(e);
        // // }
        // // Gecko
        // // Trident
        // // Webkit

        // var es6 = new Map();
        // es6.set("edition", 6);
        // es6.set("committee", "TC39");
        // es6.set("standard", "ECMA-262");
        // for (var [a, b, c = 'asd'] of es6) {
        //     console.log(a + ": " + b + ": " + c);
        // }

        // for (var [...e] of es6) {
        //     console.log(e[0] + ": " + e[1]);
        // }

        // for (var item of es6) { //item是个数组
        //     console.log(item + ": " + item);
        // }

        // const arr = ['red', 'green', 'blue'];
        // log(arr.keys());
        // log(arr.values())
        // log(arr.entries());

        // let iterator=arr[Symbol.iterator]();
        // log(iterator.next());
        // log(iterator.next());
        // log(iterator.next());

        // for (let v of arr) {
        //     console.log(v); // red green blue
        // }

        // const obj = {};
        // obj[Symbol.iterator] = [][Symbol.iterator].bind(arr);

        // for (let v of obj) {
        //     console.log(v); // red green blue
        // }

        // // 一个为对象添加 Iterator 接口的例子 start
        // let obj = {
        //     data: [ 'hello', 'world' ],
        //     [Symbol.iterator]() {
        //         const self = this;
        //         let index = 0;
        //          return {
        //             // next : function  next() {
        //                 next() {
        //                 if (index < self.data.length) {
        //                 return {
        //                     value: self.data[index++],
        //                     done: false
        //                 };
        //                 }
        //                 return { value: undefined, done: true };
        //             }
        //         }

        //     }
        // };
        // let it=obj[Symbol.iterator]();
        // log( it.next());
        // log( it.next());
        // log( it.next());

        // for(let item of obj){
        //     console.log(item);
        // }

        // 一个为对象添加 Iterator 接口的例子 end

        // 遍历器实现“链表”结构的例子 start
        // function Obj(value) {
        //     this.value = value;
        //     this.nextNode = null;
        //     this[Symbol.iterator] = function () {
        //         var iterator = { next: next };
        //         var current = this;

        //         function next() {
        //             if (current) {
        //                 var value = current.value;
        //                 current = current.nextNode;
        //                 return { done: false, value: value };
        //             }
        //             return { done: true };
        //         }
        //         return iterator;
        //     }
        // }

        // // Obj.prototype[Symbol.iterator] = function () {
        // //     var iterator = { next: next };
        // //     var current = this;

        // //     function next() {
        // //         if (current) {
        // //             var value = current.value;
        // //             current = current.nextNode;
        // //             return { done: false, value: value };
        // //         }
        // //         return { done: true };
        // //     }
        // //     return iterator;
        // // }

        // // one:{value:1,nextNode:two},two:{value:2,nextNode:two},three:{value:3,nextNode:null}

        // var one = new Obj(1);
        // var two = new Obj(2);
        // var three = new Obj(3);
        // one.nextNode = two;
        // two.nextNode = three;

        // it = one[Symbol.iterator]();// 取得one中的遍历器         -》函数名为 【Symbol.iterator】
        // //                                                      -》它是一个闭包
        // //                                                      -》闭包中有两个全局变量iterator 和 current ，一个函数next
        // //                                                      -》 current 表示当前对象 one{value:1,nextNode:two}
        // //                                                      -》 iterator 表示遍历器，它指向函数next
        // //                                                     -》  每次遍历 只会执行闭包中的函数next
        // //                                                     -》 next一旦执行 全局变量current就会指向下一个对象two,
        // console.log(it.next()); //{ done: false, value: 1 }     ->执行闭包中的方法next
        // console.log(it.next()); //{ done: false, value: 2 }
        // console.log(it.next()); //{ done: false, value: 3 }

        // // for (var i of one) {
        // //     console.log(i); // 1, 2, 3
        // // }
        // 遍历器实现“链表”结构的例子 end



        // class RangeIterator {
        //     constructor(start, stop) {
        //         this.value = start;
        //         this.stop = stop;
        //     }

        //     [Symbol.iterator]() { return this; }

        //     next() {
        //         var value = this.value;
        //         if (value <= this.stop) {
        //             this.value++;
        //             return { done: false, value: value };
        //         }
        //         return { done: true, value: undefined };
        //     }
        // }


        // let it = new RangeIterator(1, 2);
        // // log(it[Symbol.iterator]().next());
        // // log(it[Symbol.iterator]().next());
        // // log(it[Symbol.iterator]().next());

        // for (let value of it) {
        //     log(value);
        // }

        // // function range(start, stop) {
        // //     return new RangeIterator(start, stop);
        // // }

        // // for (var value of range(0, 3)) {
        // //     console.log(value); // 0, 1, 2
        // // }

        // 原生具备 Iterator 接口的数据结构如下。
        // Array
        // Map
        // Set
        // String
        // TypedArray
        // 函数的 arguments 对象
        // NodeList 对象
        // let arr = ['a', 'b', 'c'];
        // let iter = arr[Symbol.iterator]();
        // log(iter.next()) // { value: 'a', done: false }
        // log(iter.next()) // { value: 'b', done: false }
        // log(iter.next()) // { value: 'c', done: false }
        // log(iter.next())// { value: undefined, done: true }

        // var it = makeIterator(['a', 'b']);// 创建一个遍历器
        // console.log(it.next()); // { value: "a", done: false }
        // console.log(it.next()); // { value: "b", done: false }
        // console.log(it.next()); // { value: undefined, done: true }
        // console.log(it.next()); // { value: undefined, done: true }
        // console.log(it.next()); // { value: undefined, done: true }
        // console.log(it.next()); // { value: undefined, done: true }
        // function makeIterator(array) {
        //     var nextIndex = 0;
        //     return {
        //         next: function () {
        //             return nextIndex < array.length ?
        //                 { value: array[nextIndex++], done: false } :
        //                 {  done: true };
        //                 // { value: undefined, done: true };
        //         }
        //     };
        // }
    </script>
</head>

<body>

</body>

</html>